home *** CD-ROM | disk | FTP | other *** search
/ Aminet 3 / Aminet 3 - July 1994.iso / Aminet / util / misc / GadMget.lha / GadMget / Source / GadMget.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-09  |  13.0 KB  |  602 lines
  1. /* GadMGet.c  by Jeremy Friesner -- jfriesne@ucsd.edu  
  2.    Version 1.0, released 09 June 1994 */
  3.  
  4. #ifndef MGET_C
  5. #define MGET_C
  6.  
  7. #define INTUI_V36_NAMES_ONLY
  8. #define NAMELENGTH 81
  9. #define MAXFILELINELENGTH 150
  10. #define CHAR_SPACE 32
  11. #define MAXOUTPUTLINELENGTH 254
  12.  
  13. #include "GadMget.h"
  14.  
  15. extern UWORD lastcode;
  16. extern struct NewGadget mgetNGad[];
  17. int IntuitionBase; 
  18. ULONG winopenerror, lockscrnerror;
  19. ULONG handlereturn;
  20. BOOL done=FALSE;
  21. char windowtitle[75];
  22. char version[] = "$VER: GadMget V1.0";
  23.  
  24. struct Library *Intuitionbase;
  25. struct GraphicsLib *GraphicsBase;
  26. struct Library *GadToolsBase;
  27. struct Library *UtilityBase;
  28.  
  29. struct IntuiMessage *message = NULL;
  30. struct List *filelist, *getlist;
  31.  
  32. char inputfile[50];
  33. int files_selected = 0, screenisopen = 0, windowisopen = 0;
  34. int noparse = 0, nomget = 0, nosplit = 0;
  35. ULONG kbytes_selected = 0;
  36.  
  37. struct EasyStruct aboutreq =
  38.     {
  39.     sizeof(struct EasyStruct),
  40.     0,
  41.     "GadMget 1.0",
  42.     "\nGadMget 1.0\n\nby Jeremy Friesner\njfriesne@ucsd.edu\n",
  43.     "Ok",
  44.     };
  45.  
  46. void debug(int a)
  47. {
  48. printf("debug %i\n",a);
  49. Delay(40);
  50. }
  51.  
  52. int listviewgadgetClicked (VOID)
  53. {
  54. int i;
  55. struct Node *current = filelist->lh_Head;
  56. struct Gadget *toplist = mgetGadgets[0];
  57. struct Gadget *botlist = mgetGadgets[1];
  58. char *dataline = NULL;
  59. int oktosend = 1;
  60.  
  61. for (i=0; i<lastcode; i++)
  62.     {
  63.     current = current->ln_Succ;
  64.     }
  65.  
  66. if (current != NULL)
  67.     {
  68.     /* check to make sure string is a valid file line */
  69.     dataline = current->ln_Name;
  70.     if (dataline == NULL) oktosend = 0;
  71.     if (strlen(current->ln_Name) <2) oktosend = 0;
  72.         
  73.     if (!noparse)
  74.         {
  75.         if ((dataline[0] < '0')&&(dataline[0] > 'z')) oktosend = 0;
  76.         if ((dataline[35] != 'K')&&(dataline[35] != 'M')) oktosend = 0;
  77.         if (dataline[21] < '0') oktosend = 0;
  78.         }
  79.     
  80.     
  81.     if (oktosend)
  82.         {
  83.         UpdateByteCount(dataline,1);
  84.         /* Take it out of filelist */
  85.         GT_SetGadgetAttrs(toplist, mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  86.         Remove(current);
  87.         GT_SetGadgetAttrs(toplist, mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  88.     
  89.         /* And insert it in getlist */
  90.         /* first detach list to modify it */
  91.         GT_SetGadgetAttrs(botlist, mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  92.         AddTail(getlist,current);
  93.         GT_SetGadgetAttrs(botlist, mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  94.         files_selected++;
  95.         if (!noparse) ChangeWindowTitle();
  96.         }
  97.     }
  98.     
  99. }
  100.  
  101. int list2Clicked (VOID)
  102. {
  103. /* This function will move a clicked item from the lower list to the upper one */
  104.  
  105. int i;
  106. struct Node *current = getlist->lh_Head;
  107. struct Gadget *toplist = mgetGadgets[0];
  108. struct Gadget *botlist = mgetGadgets[1];
  109.  
  110. for (i=0; i<lastcode; i++)
  111.     {
  112.     current = current->ln_Succ;
  113.     }
  114.  
  115. UpdateByteCount(current->ln_Name,-1);
  116.  
  117. /* Take it out of getlist */
  118. GT_SetGadgetAttrs(botlist, mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  119. Remove(current);
  120. GT_SetGadgetAttrs(botlist, mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  121.  
  122.  
  123. /* And insert it in filelist */
  124. GT_SetGadgetAttrs(toplist, mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  125. AddTail(filelist,current);
  126. GT_SetGadgetAttrs(toplist, mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  127. /* and that's it! */
  128.  
  129. files_selected--;
  130. if (!noparse) ChangeWindowTitle();
  131. }
  132.  
  133. int OutputList(struct List *thislist)
  134. {
  135. char *j, *j2;
  136. int i=0,k,l,z,q,next_bytes;
  137. int next_splitpoint = MAXOUTPUTLINELENGTH, printed_bytes = 0;
  138. char outname[80];
  139. struct Node *current = thislist->lh_Head;
  140.  
  141. if (!nomget) {printf("mget "); printed_bytes = 5;}
  142.  
  143.  while (current != NULL)
  144.  {
  145.     /* watch out for empty nodes! */
  146.     i++;
  147.     
  148.     if (current->ln_Name != NULL)
  149.         {
  150.         z = strlen(current->ln_Name);
  151.         }
  152.         else
  153.         {
  154.         z=0;
  155.         }
  156.     
  157.     if (z>21)
  158.         {
  159.         j = strchr(current->ln_Name,' ');   /* address of first space after filename */
  160.         k = j - current->ln_Name;           /* length of filename */
  161.         j2 = strchr(current->ln_Name+21,' ');   /* address of directory of file */
  162.         l = j2 - (current->ln_Name) - 21;        /* length of directory */
  163.  
  164.         if ((k<22)&&(k>0)&&(l<12)&&(l>2))
  165.             {
  166.             for (q=0;q<80;q++)
  167.                 outname[q]=0;
  168.             strncat(outname,current->ln_Name+21,l);
  169.             strncat(outname,"/",1);
  170.             strncat(outname,current->ln_Name,k);
  171.             outname[79]=0;    /* just in case, we'll reterminate the string */
  172.             next_bytes = strlen(outname) + 1;    /* + 1 for the space */
  173.             if ((next_bytes>3)&&(next_bytes<33))
  174.                 {
  175.                 if ((!nosplit)&&((printed_bytes + next_bytes) > next_splitpoint))
  176.                     {
  177.                     if (nomget) 
  178.                         {
  179.                         printf("\r\n");
  180.                         printed_bytes = 0;
  181.                         }
  182.                         else
  183.                         {
  184.                         printf("\r\nmget ");
  185.                         printed_bytes = 5;    /* reset counter for next batch */
  186.                         }
  187.                         
  188.                     }
  189.             
  190.                 printf("%s ",outname);
  191.                 printed_bytes = printed_bytes + next_bytes;
  192.                 }
  193.             }
  194.         }    
  195.     current = current->ln_Succ;    
  196.     }
  197. return(1);
  198.  
  199. }
  200.  
  201. int RawOutputList(struct List *thislist)
  202. {
  203. struct Node *current = thislist->lh_Head;
  204.  
  205. while (current != NULL)
  206.     {    
  207.     if ((current->ln_Name != NULL)&&
  208.         (*current->ln_Name != 10)&&
  209.         (*current->ln_Name != 13))
  210.             {
  211.             printf("%.80s\n",current->ln_Name);
  212.             }
  213.     current = current->ln_Succ;
  214.     }
  215. return(1);
  216. }
  217.  
  218. int mgetabout (VOID)
  219. {
  220. EasyRequest(NULL, &aboutreq, NULL, "(Variable)", NULL /* was number */);
  221. }
  222.  
  223. int mgetquit (VOID)
  224. {
  225. done=TRUE;
  226. }
  227.  
  228. int mgetcopy (VOID)
  229. {
  230. /* printf ("Copy menu item selected 64\n"); */
  231. }
  232.  
  233. int mgetcut (VOID)
  234. {
  235. /* printf ("Cut menu item selected 65\n"); */
  236. }
  237.  
  238. int mgetpaste (void)
  239. {
  240. /* printf("Paste menu item selected 66\n"); */
  241. }
  242.  
  243. int mgetCloseWindow (void)
  244. {
  245. done=TRUE;
  246. }
  247.  
  248.  
  249.  
  250. /* Turns all \n's in input string into <space><newline>'s */
  251. void FindReturns(char *mystring)
  252. {
  253. char *thischar=mystring, *prevchar=mystring;
  254.  
  255. while (*thischar != NULL)
  256.     {
  257.     
  258.     if ( (*prevchar  ==   92) &&                        /* any '/'s ? */
  259.          ((*thischar ==   78)||(*thischar == 110)) &&      /* N's or n's */
  260.          (prevchar   !=  NULL) &&                        /* Sanity chk */
  261.          (thischar   !=  NULL))
  262.         
  263.         {
  264.         *prevchar = 32;   /* set this to a space--easier than shortening string */
  265.         *thischar = 10;   /* and end this line with a newline char */
  266.         }
  267.     
  268.     prevchar = thischar;
  269.     thischar++;
  270.     }
  271. }
  272.  
  273. int AddFile(struct List *mylist, char *newstring)   /* 1 = success, 0 = failure */
  274. {
  275. struct Node *newnode;
  276. char *newname, *i, returnchar = 10, spacechar = 32;
  277. UBYTE diff=NAMELENGTH;
  278.  
  279. if (strlen(newstring) < 1) return(0);
  280.  
  281. /* make sure there are carriage returns in newname! */
  282.  
  283. if (!( newnode = AllocMem(sizeof(struct Node),MEMF_CLEAR) ))
  284.     {
  285.     printf("Couldn't allocate memory for Node!\n");
  286.     return(0);
  287.     }
  288.  
  289. i = strchr(newstring, (char) returnchar);
  290. if (i)
  291.     {
  292.     diff = i-newstring;  /* number of chars into the string where newline is! */
  293.     }
  294.  
  295.  
  296. if (!( newname = AllocMem(diff+1,MEMF_CLEAR) ))
  297.     {
  298.     printf("Couldn't allocate memory for Node String!  %i\n",diff);
  299.     return(0);
  300.     }
  301.  
  302. strncpy(newname,newstring,diff);   /* copy over the bytes */
  303.  
  304. newnode->ln_Pri = diff - 126;        /* store string length in unused field */
  305.                             /* really bad style, isn't it? */
  306.                         
  307. newnode->ln_Name=newname;          /* and set ze pointer! */
  308.  
  309. AddTail(mylist, newnode);
  310. return(1);
  311. }
  312.  
  313. /* returns the number of lines successfully parsed and added to the list */
  314. int ReadmyFile(void)
  315. {
  316. FILE *input_file;
  317. char inputline[MAXFILELINELENGTH];
  318. char *firstnull;
  319. int i,nullpos = 0, okline = 0;
  320. int filelength = 0, failed_lines = 0, added_lines = 0;
  321.  
  322. if (input_file = fopen(inputfile,"r"))
  323.     {
  324.     while (!feof(input_file))
  325.         {
  326.         filelength++;        
  327.         okline=0;  
  328.         /* Read until we get a line-end */
  329.         while((okline==0)&&(!feof(input_file)))
  330.             {
  331.             for(i=0; ((i<MAXFILELINELENGTH)&&(inputline[i] != 0)); i++)
  332.             {
  333.             inputline[i] = 0;
  334.             }
  335.             fgets(inputline,NAMELENGTH,input_file);  /* Read up to 80 chars from inputfile */
  336.             firstnull = strchr(inputline,(char) 10); /* Find address of carriage return */
  337.             nullpos = firstnull - inputline;           /* Subtract to get return pos */
  338.             if ((nullpos > 1)&&(nullpos < NAMELENGTH)) okline=1;
  339.             }
  340.         if ((nullpos < NAMELENGTH)||(noparse))
  341.                   {
  342.                   if (AddFile(filelist, inputline) == 1)
  343.                       {
  344.                       added_lines++;
  345.                       }
  346.                       else
  347.                       {
  348.                       failed_lines++;
  349.                       }
  350.                   }
  351.                   else
  352.                   {
  353.                   failed_lines++;
  354.                   }
  355.                   
  356.         }
  357.     }
  358.     else
  359.     {
  360.     printf("Couldn't open file!\n");
  361.     return(0);
  362.     }
  363.  
  364. fclose(input_file);
  365. return(added_lines);
  366. }
  367.  
  368. VOID FreeFileNodes(struct List *mylist)
  369. {
  370. struct Node *nextnode,*worknode = mylist->lh_Head;  
  371. int nodesize = sizeof(struct Node);
  372.  
  373. while (nextnode = (worknode->ln_Succ))
  374.     {
  375.     if (worknode->ln_Name != NULL)
  376.         {
  377.         FreeMem(worknode->ln_Name,worknode->ln_Pri+127);
  378.         }
  379.         
  380.     FreeMem(worknode,nodesize);
  381.     worknode = nextnode;
  382.     }
  383. }
  384.  
  385.  
  386. int ChangeWindowTitle(void)
  387. {
  388. sprintf(windowtitle,"%i files, %u kilobytes selected.",files_selected, kbytes_selected);   
  389. SetWindowTitles(mgetWnd, windowtitle , (char *) ~0); 
  390. return(1);
  391. }
  392.  
  393.  
  394. VOID UpdateByteCount(char *mystring, int addorsub)
  395. {
  396. int multiplier = 0;
  397. int filesize = 0, wholenum;
  398. int outputlength = -1;
  399.  
  400. if (mystring == NULL) {printf("UBC: mystring null!\n"); return(); }
  401.  
  402. if (mystring[35] == 'M') multiplier = 1024;   /* 1024 k in a M */
  403. if (mystring[35] == 'K') multiplier = 1;     /* 1 k in a k */
  404.  
  405. if (multiplier == 0) {return();}    /* If we don't know M or K, abort */
  406.  
  407. if (mystring[33] == '.')
  408.     {
  409.     /* figure out kilobytes */
  410.     wholenum = (int) (mystring[32] - 48);
  411.     
  412.     if ((wholenum >= 0)&&(wholenum <= 9))
  413.         {
  414.         filesize = filesize + (multiplier * wholenum);
  415.         }
  416.  
  417.     wholenum = (int) (mystring[34] - 48);
  418.     if ((wholenum >= 0)&&(wholenum <= 9))
  419.         {
  420.         filesize = filesize + ((multiplier/10) * wholenum);
  421.         }
  422.     }
  423.     else
  424.     {
  425.     wholenum = (int) (mystring[32] - 48);
  426.     if ((wholenum >= 0)&&(wholenum <= 9))
  427.         {
  428.         filesize = filesize + (100 * multiplier * wholenum);
  429.         }
  430.         
  431.     wholenum = (int) (mystring[33] - 48);
  432.         if ((wholenum >= 0)&&(wholenum <= 9))
  433.         {
  434.         filesize = filesize + ( 10 * multiplier * wholenum);
  435.         }
  436.  
  437.     wholenum = (int) (mystring[34] - 48);
  438.     if ((wholenum >= 0)&&(wholenum <= 9))
  439.         {
  440.         filesize = filesize + (  1 * multiplier * wholenum);
  441.         }
  442.     }
  443.     
  444. kbytes_selected = kbytes_selected + (filesize * addorsub);
  445. return();
  446.  
  447. }
  448.  
  449.  
  450. VOID Cleanup(void)
  451. {
  452. if (windowisopen)  ClosemgetWindow();
  453. if (screenisopen)  CloseDownScreen();
  454. if (filelist)        {
  455.                 FreeFileNodes(filelist); 
  456.                 FreeMem(filelist,sizeof(struct List));
  457.                 }
  458. if (getlist)       {
  459.                 FreeFileNodes(getlist);
  460.                 FreeMem(getlist,sizeof(struct List));
  461.                 }
  462. if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  463. if (UtilityBase)   CloseLibrary((struct Library *)UtilityBase);
  464. if (GraphicsBase)  CloseLibrary((struct GraphicsLib *)GraphicsBase);
  465. if (GadToolsBase)  CloseLibrary((struct Library *)GadToolsBase);
  466. return();
  467. }
  468.  
  469.  
  470. /********/
  471. /* MAIN */
  472. /********/
  473. VOID main(int argc, char *argv[])
  474. {
  475.  
  476. /* if argc=1 then no arguments.  If argc =2 then one arg, etc. */
  477. if (argc==0) 
  478.     {
  479.     return();
  480.     }
  481.     
  482. inputfile[0] = 0;
  483. if (argc==1) 
  484.     {
  485.     printf("Template:  GadMGet FILE/S NOPARSE/K NOMGET/K NOSPLIT/K\n");
  486.     return();
  487.     }
  488.  
  489. /* by here, argc > 1 */
  490. strncpy(inputfile,argv[1],50);
  491. if (*inputfile == '?')
  492.     {
  493.     printf("Template:  GadMGet FILE/S NOPARSE/K NOMGET/K NOSPLIT/K\n");
  494.     return();
  495.     }
  496.  
  497. for (int i=3; i<=argc; i++)
  498.     {
  499.     if ((strncmp(argv[i-1],"NOPARSE",7) == 0)||
  500.         (strncmp(argv[i-1],"noparse",7) == 0)||
  501.         (strncmp(argv[i-1],"Noparse",7) == 0)||
  502.         (strncmp(argv[i-1],"NoParse",7) == 0)) noparse = 1;
  503.         
  504.     if ((strncmp(argv[i-1],"NOMGET",6) == 0)||
  505.         (strncmp(argv[i-1],"nomget",6) == 0)||
  506.         (strncmp(argv[i-1],"Nomget",6) == 0)||
  507.         (strncmp(argv[i-1],"NoMget",6) == 0)) nomget = 1;
  508.  
  509.     if ((strncmp(argv[i-1],"NOSPLIT",7) == 0)||
  510.         (strncmp(argv[i-1],"nosplit",7) == 0)||
  511.         (strncmp(argv[i-1],"Nosplit",7) == 0)||
  512.         (strncmp(argv[i-1],"NoSplit",7) == 0)) nosplit = 1;
  513.     }
  514.     
  515. GraphicsBase = OpenLibrary("graphics.library",37);
  516. if (GraphicsBase==NULL)
  517.     {
  518.     printf("couldn't open Graphics.library v37!");
  519.     return;
  520.     }
  521. UtilityBase = OpenLibrary("utility.library",37);
  522. if (UtilityBase==NULL)
  523.     {
  524.     printf("couldn't open utility.library v37!");
  525.     return;
  526.     }
  527. GadToolsBase = OpenLibrary("gadtools.library",37);
  528. if (GadToolsBase==NULL)
  529.     {
  530.     printf("couldn't open gadtools.library v37!\n");
  531.     return;
  532.     }
  533. IntuitionBase = OpenLibrary("intuition.library",37);
  534. if (IntuitionBase)
  535.     {        
  536.     /* Now add data to listView */
  537.     /* First, initialize List filelist */
  538.     
  539.     if (!(filelist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  540.         {
  541.         printf("Couldn't create filelist!  Out of memory?\n");
  542.         Cleanup();
  543.         return();
  544.         }
  545.     if (!(getlist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  546.         {
  547.         printf("Couldn't create getlist!  Out of memory?\n");
  548.         Cleanup();
  549.         return();
  550.         }
  551.  
  552.     NewList(filelist);
  553.     NewList(getlist);
  554.  
  555.     lockscrnerror = SetupScreen();
  556.     if (lockscrnerror)
  557.         {
  558.         printf("couldn't open screen!\n");
  559.         Cleanup();
  560.         return();
  561.         }
  562.     screenisopen = 1;
  563.             
  564.     winopenerror = OpenmgetWindow();
  565.     if (winopenerror)
  566.         {
  567.         printf("Couldn't open window!\n");
  568.         Cleanup();
  569.         return();
  570.         }
  571.     windowisopen = 1;
  572.  
  573.     if (ReadmyFile() > 0)
  574.         {                
  575.         /* Put list into top list */
  576.              GT_SetGadgetAttrs((struct Gadget *) mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  577.         files_selected = 0;
  578.     
  579.         if (noparse) SetWindowTitles(mgetWnd, "Please select desired lines now." , (char *) ~0); 
  580.                    else ChangeWindowTitle();
  581.  
  582.         while (done==FALSE)
  583.             {
  584.             Wait(1L << mgetWnd->UserPort->mp_SigBit);
  585.             handlereturn = HandlemgetIDCMP();
  586.             }    
  587.         if (files_selected > 0) 
  588.             {
  589.             if (noparse) RawOutputList(getlist);
  590.                    else OutputList(getlist); 
  591.             }
  592.         }
  593.     }
  594. Cleanup();
  595. return();    
  596. }
  597.  
  598. #endif
  599.  
  600.  
  601.     
  602.